home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / itc / cc1.spur / insn-output.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-30  |  20.7 KB  |  1,204 lines
  1. /* Generated automatically by the program `genoutput'
  2. from the machine description file `md'.  */
  3.  
  4. #include "config.h"
  5. #include "rtl.h"
  6. #include "regs.h"
  7. #include "conditions.h"
  8. #include "insn-flags.h"
  9. #include "insn-config.h"
  10.  
  11. #include "output.h"
  12. #include "aux-output.c"
  13.  
  14.  
  15. char *
  16. output_0 (operands, insn)
  17.      rtx *operands;
  18.      rtx insn;
  19. {
  20.  
  21. {
  22.   cc_status.value1 = operands[0], cc_status.value2 = operands[1];
  23.   return "";
  24. }
  25. }
  26.  
  27. char *
  28. output_1 (operands, insn)
  29.      rtx *operands;
  30.      rtx insn;
  31. {
  32.  
  33. {
  34.   cc_status.value1 = operands[0], cc_status.value2 = const0_rtx;
  35.   return "";
  36. }
  37. }
  38.  
  39. char *
  40. output_2 (operands, insn)
  41.      rtx *operands;
  42.      rtx insn;
  43. {
  44.  return output_compare (operands, "eq", "eq", "ne", "ne"); 
  45. }
  46.  
  47. char *
  48. output_3 (operands, insn)
  49.      rtx *operands;
  50.      rtx insn;
  51. {
  52.  return output_compare (operands, "ne", "ne", "eq", "eq"); 
  53. }
  54.  
  55. char *
  56. output_4 (operands, insn)
  57.      rtx *operands;
  58.      rtx insn;
  59. {
  60.  return output_compare (operands, "gt", "lt", "le", "ge"); 
  61. }
  62.  
  63. char *
  64. output_5 (operands, insn)
  65.      rtx *operands;
  66.      rtx insn;
  67. {
  68.  return output_compare (operands, "ugt", "ult", "ule", "uge"); 
  69. }
  70.  
  71. char *
  72. output_6 (operands, insn)
  73.      rtx *operands;
  74.      rtx insn;
  75. {
  76.  return output_compare (operands, "lt", "gt", "ge", "le"); 
  77. }
  78.  
  79. char *
  80. output_7 (operands, insn)
  81.      rtx *operands;
  82.      rtx insn;
  83. {
  84.  return output_compare (operands, "ult", "ugt", "uge", "ule"); 
  85. }
  86.  
  87. char *
  88. output_8 (operands, insn)
  89.      rtx *operands;
  90.      rtx insn;
  91. {
  92.  return output_compare (operands, "ge", "le", "lt", "gt"); 
  93. }
  94.  
  95. char *
  96. output_9 (operands, insn)
  97.      rtx *operands;
  98.      rtx insn;
  99. {
  100.  return output_compare (operands, "uge", "ule", "ult", "ugt"); 
  101. }
  102.  
  103. char *
  104. output_10 (operands, insn)
  105.      rtx *operands;
  106.      rtx insn;
  107. {
  108.  return output_compare (operands, "le", "ge", "gt", "lt"); 
  109. }
  110.  
  111. char *
  112. output_11 (operands, insn)
  113.      rtx *operands;
  114.      rtx insn;
  115. {
  116.  return output_compare (operands, "ule", "uge", "ugt", "ult"); 
  117. }
  118.  
  119. char *
  120. output_12 (operands, insn)
  121.      rtx *operands;
  122.      rtx insn;
  123. {
  124.  return output_compare (operands, "ne", "ne", "eq", "eq"); 
  125. }
  126.  
  127. char *
  128. output_13 (operands, insn)
  129.      rtx *operands;
  130.      rtx insn;
  131. {
  132.  return output_compare (operands, "eq", "eq", "ne", "ne"); 
  133. }
  134.  
  135. char *
  136. output_14 (operands, insn)
  137.      rtx *operands;
  138.      rtx insn;
  139. {
  140.  return output_compare (operands, "le", "ge", "gt", "lt"); 
  141. }
  142.  
  143. char *
  144. output_15 (operands, insn)
  145.      rtx *operands;
  146.      rtx insn;
  147. {
  148.  return output_compare (operands, "ule", "uge", "ugt", "ult"); 
  149. }
  150.  
  151. char *
  152. output_16 (operands, insn)
  153.      rtx *operands;
  154.      rtx insn;
  155. {
  156.  return output_compare (operands, "ge", "le", "lt", "gt"); 
  157. }
  158.  
  159. char *
  160. output_17 (operands, insn)
  161.      rtx *operands;
  162.      rtx insn;
  163. {
  164.  return output_compare (operands, "uge", "ule", "ult", "ugt"); 
  165. }
  166.  
  167. char *
  168. output_18 (operands, insn)
  169.      rtx *operands;
  170.      rtx insn;
  171. {
  172.  return output_compare (operands, "lt", "gt", "ge", "le"); 
  173. }
  174.  
  175. char *
  176. output_19 (operands, insn)
  177.      rtx *operands;
  178.      rtx insn;
  179. {
  180.  return output_compare (operands, "ult", "ugt", "uge", "ule"); 
  181. }
  182.  
  183. char *
  184. output_20 (operands, insn)
  185.      rtx *operands;
  186.      rtx insn;
  187. {
  188.  return output_compare (operands, "gt", "lt", "le", "ge"); 
  189. }
  190.  
  191. char *
  192. output_21 (operands, insn)
  193.      rtx *operands;
  194.      rtx insn;
  195. {
  196.  return output_compare (operands, "ugt", "ult", "ule", "uge"); 
  197. }
  198.  
  199. char *
  200. output_22 (operands, insn)
  201.      rtx *operands;
  202.      rtx insn;
  203. {
  204.  
  205. {
  206.   if (GET_CODE (operands[0]) == MEM)
  207.     return "st_32 %r1,%0";
  208.   if (GET_CODE (operands[1]) == MEM)
  209.     return "ld_32 %0,%1\n\tnop";
  210.   if (GET_CODE (operands[1]) == REG)
  211.     return "add_nt %0,%1,$0";
  212.   if (GET_CODE (operands[1]) == SYMBOL_REF && operands[1]->unchanging)
  213.     return "add_nt %0,r24,$(%1-0b)";
  214.   return "add_nt %0,r0,%1";
  215. }
  216. }
  217.  
  218. char *
  219. output_25 (operands, insn)
  220.      rtx *operands;
  221.      rtx insn;
  222. {
  223.  
  224. {
  225.   if (GET_CODE (operands[0]) == MEM)
  226.     return "st_32 %1,%0";
  227.   if (GET_CODE (operands[1]) == MEM)
  228.     return "ld_32 %0,%1\n\tnop";
  229.   if (GET_CODE (operands[1]) == REG)
  230.     return "add_nt %0,%1,$0";
  231.   return "add_nt %0,r0,%1";
  232. }
  233. }
  234.  
  235. char *
  236. output_32 (operands, insn)
  237.      rtx *operands;
  238.      rtx insn;
  239. {
  240.  
  241. {
  242.   if (GET_CODE (operands[0]) == MEM)
  243.     return "st_32 %1,%0";
  244.   if (GET_CODE (operands[1]) == MEM)
  245.     return "ld_32 %0,%1\n\tnop";
  246.   if (GET_CODE (operands[1]) == REG)
  247.     return "add_nt %0,%1,$0";
  248.   return "add_nt %0,r0,%1";
  249. }
  250. }
  251.  
  252. char *
  253. output_35 (operands, insn)
  254.      rtx *operands;
  255.      rtx insn;
  256. {
  257.  
  258. {
  259.   if (FP_REG_P (operands[0]))
  260.     return output_fp_move_double (operands);
  261.   if (operands[1] == dconst0_rtx && GET_CODE (operands[0]) == REG)
  262.     {
  263.       operands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
  264.       return "add_nt %0,r0,$0\n\tadd_nt %1,r0,$0";
  265.     }
  266.   if (operands[1] == dconst0_rtx && GET_CODE (operands[0]) == MEM)
  267.     {
  268.       operands[1] = adj_offsetable_operand (operands[0], 4);
  269.       return "st_32 r0,%0\n\tst_32 r0,%1";
  270.     }
  271.   return output_move_double (operands);
  272. }
  273.  
  274. }
  275.  
  276. char *
  277. output_36 (operands, insn)
  278.      rtx *operands;
  279.      rtx insn;
  280. {
  281.  
  282. {
  283.   if (FP_REG_P (operands[0]) || FP_REG_P (operands[1]))
  284.     return output_fp_move_double (operands);
  285.   return output_move_double (operands);
  286. }
  287.  
  288. }
  289.  
  290. char *
  291. output_37 (operands, insn)
  292.      rtx *operands;
  293.      rtx insn;
  294. {
  295.  
  296. {
  297.   if (FP_REG_P (operands[0]) || FP_REG_P (operands[1]))
  298.     return output_fp_move_double (operands);
  299.   return output_move_double (operands);
  300. }
  301.  
  302. }
  303.  
  304. char *
  305. output_38 (operands, insn)
  306.      rtx *operands;
  307.      rtx insn;
  308. {
  309.  
  310. {
  311.   if (FP_REG_P (operands[0]))
  312.     {
  313.       if (FP_REG_P (operands[1]))
  314.     return "fmov %0,%1";
  315.       if (GET_CODE (operands[1]) == REG)
  316.     {
  317.       rtx xoperands[2];
  318.       int offset = - get_frame_size () - 8;
  319.       xoperands[1] = operands[1];
  320.       xoperands[0] = gen_rtx (CONST_INT, VOIDmode, offset);
  321.       output_asm_insn ("st_32 %1,r25,%0", xoperands);
  322.       xoperands[1] = operands[0];
  323.       output_asm_insn ("ld_sgl %1,r25,%0\n\tnop", xoperands);
  324.       return "";
  325.     }
  326.       return "ld_sgl %0,%1\n\tnop";
  327.     }
  328.   if (FP_REG_P (operands[1]))
  329.     {
  330.       if (GET_CODE (operands[0]) == REG)
  331.     {
  332.       rtx xoperands[2];
  333.       int offset = - get_frame_size () - 8;
  334.       xoperands[0] = gen_rtx (CONST_INT, VOIDmode, offset);
  335.       xoperands[1] = operands[1];
  336.       output_asm_insn ("st_sgl %1,r25,%0", xoperands);
  337.       xoperands[1] = operands[0];
  338.       output_asm_insn ("ld_32 %1,r25,%0\n\tnop", xoperands);
  339.       return "";
  340.     }
  341.       return "st_sgl %1,%0";
  342.     }
  343.   if (GET_CODE (operands[0]) == MEM)
  344.     return "st_32 %r1,%0";
  345.   if (GET_CODE (operands[1]) == MEM)
  346.     return "ld_32 %0,%1\n\tnop";
  347.   if (GET_CODE (operands[1]) == REG)
  348.     return "add_nt %0,%1,$0";
  349.   return "add_nt %0,r0,%1";
  350. }
  351. }
  352.  
  353. char *
  354. output_49 (operands, insn)
  355.      rtx *operands;
  356.      rtx insn;
  357. {
  358.  
  359. {
  360.   return 
  361.      output_add_large_offset (operands[0], operands[1], INTVAL (operands[2]));
  362. }
  363. }
  364.  
  365. char *
  366. output_68 (operands, insn)
  367.      rtx *operands;
  368.      rtx insn;
  369. {
  370.  
  371. {
  372.   unsigned int amount = INTVAL (operands[2]);
  373.  
  374.   switch (amount) {
  375.   case 0:
  376.       return "add_nt %0,%1,$0";
  377.   case 1:
  378.       return "sll %0,%1,$1";
  379.   case 2:
  380.       return "sll %0,%1,$2";
  381.   default:
  382.       output_asm_insn ("sll %0,%1,$3", operands);
  383.  
  384.       for (amount -= 3; amount >= 3; amount -= 3) {
  385.       output_asm_insn ("sll %0,%0,$3", operands);
  386.       }
  387.  
  388.       if (amount > 0)
  389.       output_asm_insn (amount == 1 ? "sll %0,%0,$1" : "sll %0,%0,$2",
  390.                operands);
  391.       return "";
  392.   }
  393. }
  394. }
  395.  
  396. char *
  397. output_69 (operands, insn)
  398.      rtx *operands;
  399.      rtx insn;
  400. {
  401.  
  402. {
  403.   unsigned int amount = INTVAL (operands[2]);
  404.  
  405.   if (amount == 0) 
  406.       return "add_nt %0,%1,$0";
  407.   else
  408.       output_asm_insn ("sra %0,%1,$1", operands);
  409.   
  410.   for (amount -= 1; amount > 0; amount -= 1) {
  411.       output_asm_insn ("sra %0,%0,$1", operands);
  412.   }
  413.  
  414.   return "";
  415. }
  416. }
  417.  
  418. char *
  419. output_70 (operands, insn)
  420.      rtx *operands;
  421.      rtx insn;
  422. {
  423.  
  424. {
  425.   unsigned int amount = INTVAL (operands[2]);
  426.  
  427.   if (amount == 0) 
  428.       return "add_nt %0,%1,$0";
  429.   else
  430.       output_asm_insn ("srl %0,%1,$1", operands);
  431.   
  432.   for (amount -= 1; amount > 0; amount -= 1) {
  433.       output_asm_insn ("srl %0,%0,$1", operands);
  434.   }
  435.  
  436.   return "";
  437. }
  438. }
  439.  
  440. char *insn_template[] =
  441.   {
  442.     0,
  443.     0,
  444.     0,
  445.     0,
  446.     0,
  447.     0,
  448.     0,
  449.     0,
  450.     0,
  451.     0,
  452.     0,
  453.     0,
  454.     0,
  455.     0,
  456.     0,
  457.     0,
  458.     0,
  459.     0,
  460.     0,
  461.     0,
  462.     0,
  463.     0,
  464.     0,
  465.     "ld_32 %0,%1,%2\n\tnop",
  466.     0,
  467.     0,
  468.     "extract %0,%1,%2",
  469.     "wr_insert %1\n\tinsert %0,%0,%2",
  470.     0,
  471.     0,
  472.     0,
  473.     0,
  474.     0,
  475.     "extract %0,%1,%2",
  476.     "wr_insert %1\n\tinsert %0,%0,%2",
  477.     0,
  478.     0,
  479.     0,
  480.     0,
  481.     "add_nt %0,%1,$0",
  482.     "add_nt %0,%1,$0",
  483.     "add_nt %0,%1,$0",
  484.     0,
  485.     "extract %0,%1,$0",
  486.     "extract %0,%1,$0",
  487.     0,
  488.     0,
  489.     0,
  490.     "add %0,%1,%2",
  491.     0,
  492.     "sub %0,%1,%2",
  493.     "and %0,%1,%2",
  494.     "or %0,%1,%2",
  495.     "xor %0,%1,%2",
  496.     "sub %0,r0,%1",
  497.     "xor %0,%1,$-1",
  498.     "fadd %0,%1,%2",
  499.     "fadd %0,%1,%2",
  500.     "fsub %0,%1,%2",
  501.     "fsub %0,%1,%2",
  502.     "fmul %0,%1,%2",
  503.     "fmul %0,%1,%2",
  504.     "fdiv %0,%1,%2",
  505.     "fdiv %0,%1,%2",
  506.     "fneg %0,%1",
  507.     "fneg %0,%1",
  508.     "fabs %0,%1",
  509.     "fabs %0,%1",
  510.     0,
  511.     0,
  512.     0,
  513.     0,
  514.     0,
  515.     0,
  516.     0,
  517.     "jump %l0\n\tnop",
  518.     "jump_reg r0,%0\n\tnop",
  519.     "add_nt r2,%0\n\tcall .+8\n\tjump_reg r0,r2\n\tnop",
  520.     "add_nt r2,%1\n\tcall .+8\n\tjump_reg r0,r2\n\tnop",
  521.     "call %0\n\tnop",
  522.     "call %1\n\tnop",
  523.   };
  524.  
  525. char *(*insn_outfun[])() =
  526.   {
  527.     output_0,
  528.     output_1,
  529.     output_2,
  530.     output_3,
  531.     output_4,
  532.     output_5,
  533.     output_6,
  534.     output_7,
  535.     output_8,
  536.     output_9,
  537.     output_10,
  538.     output_11,
  539.     output_12,
  540.     output_13,
  541.     output_14,
  542.     output_15,
  543.     output_16,
  544.     output_17,
  545.     output_18,
  546.     output_19,
  547.     output_20,
  548.     output_21,
  549.     output_22,
  550.     0,
  551.     0,
  552.     output_25,
  553.     0,
  554.     0,
  555.     0,
  556.     0,
  557.     0,
  558.     0,
  559.     output_32,
  560.     0,
  561.     0,
  562.     output_35,
  563.     output_36,
  564.     output_37,
  565.     output_38,
  566.     0,
  567.     0,
  568.     0,
  569.     0,
  570.     0,
  571.     0,
  572.     0,
  573.     0,
  574.     0,
  575.     0,
  576.     output_49,
  577.     0,
  578.     0,
  579.     0,
  580.     0,
  581.     0,
  582.     0,
  583.     0,
  584.     0,
  585.     0,
  586.     0,
  587.     0,
  588.     0,
  589.     0,
  590.     0,
  591.     0,
  592.     0,
  593.     0,
  594.     0,
  595.     output_68,
  596.     output_69,
  597.     output_70,
  598.     0,
  599.     0,
  600.     0,
  601.     0,
  602.     0,
  603.     0,
  604.     0,
  605.     0,
  606.     0,
  607.     0,
  608.   };
  609.  
  610. rtx (*insn_gen_function[]) () =
  611.   {
  612.     gen_cmpsi,
  613.     gen_tstsi,
  614.     gen_beq,
  615.     gen_bne,
  616.     gen_bgt,
  617.     gen_bgtu,
  618.     gen_blt,
  619.     gen_bltu,
  620.     gen_bge,
  621.     gen_bgeu,
  622.     gen_ble,
  623.     gen_bleu,
  624.     0,
  625.     0,
  626.     0,
  627.     0,
  628.     0,
  629.     0,
  630.     0,
  631.     0,
  632.     0,
  633.     0,
  634.     gen_movsi,
  635.     0,
  636.     gen_movqi,
  637.     0,
  638.     0,
  639.     0,
  640.     gen_loadhi,
  641.     gen_storehi,
  642.     gen_storeinthi,
  643.     gen_movhi,
  644.     0,
  645.     0,
  646.     0,
  647.     0,
  648.     gen_movdf,
  649.     gen_movdi,
  650.     gen_movsf,
  651.     gen_truncsiqi2,
  652.     gen_trunchiqi2,
  653.     gen_truncsihi2,
  654.     gen_zero_extendhisi2,
  655.     gen_zero_extendqihi2,
  656.     gen_zero_extendqisi2,
  657.     gen_extendhisi2,
  658.     gen_extendqihi2,
  659.     gen_extendqisi2,
  660.     gen_addsi3,
  661.     0,
  662.     gen_subsi3,
  663.     gen_andsi3,
  664.     gen_iorsi3,
  665.     gen_xorsi3,
  666.     gen_negsi2,
  667.     gen_one_cmplsi2,
  668.     gen_adddf3,
  669.     gen_addsf3,
  670.     gen_subdf3,
  671.     gen_subsf3,
  672.     gen_muldf3,
  673.     gen_mulsf3,
  674.     gen_divdf3,
  675.     gen_divsf3,
  676.     gen_negdf2,
  677.     gen_negsf2,
  678.     gen_absdf2,
  679.     gen_abssf2,
  680.     0,
  681.     0,
  682.     0,
  683.     gen_ashlsi3,
  684.     gen_lshlsi3,
  685.     gen_ashrsi3,
  686.     gen_lshrsi3,
  687.     gen_jump,
  688.     gen_tablejump,
  689.     gen_call,
  690.     gen_call_value,
  691.     0,
  692.     0,
  693.   };
  694.  
  695. int insn_n_operands[] =
  696.   {
  697.     2,
  698.     1,
  699.     0,
  700.     0,
  701.     0,
  702.     0,
  703.     0,
  704.     0,
  705.     0,
  706.     0,
  707.     0,
  708.     0,
  709.     0,
  710.     0,
  711.     0,
  712.     0,
  713.     0,
  714.     0,
  715.     0,
  716.     0,
  717.     0,
  718.     0,
  719.     2,
  720.     3,
  721.     2,
  722.     2,
  723.     3,
  724.     3,
  725.     5,
  726.     5,
  727.     4,
  728.     2,
  729.     2,
  730.     3,
  731.     3,
  732.     2,
  733.     2,
  734.     2,
  735.     2,
  736.     2,
  737.     2,
  738.     2,
  739.     2,
  740.     2,
  741.     2,
  742.     2,
  743.     2,
  744.     2,
  745.     3,
  746.     3,
  747.     3,
  748.     3,
  749.     3,
  750.     3,
  751.     2,
  752.     2,
  753.     3,
  754.     3,
  755.     3,
  756.     3,
  757.     3,
  758.     3,
  759.     3,
  760.     3,
  761.     2,
  762.     2,
  763.     2,
  764.     2,
  765.     3,
  766.     3,
  767.     3,
  768.     3,
  769.     3,
  770.     3,
  771.     3,
  772.     0,
  773.     1,
  774.     2,
  775.     3,
  776.     2,
  777.     3,
  778.   };
  779.  
  780. int insn_n_dups[] =
  781.   {
  782.     0,
  783.     0,
  784.     0,
  785.     0,
  786.     0,
  787.     0,
  788.     0,
  789.     0,
  790.     0,
  791.     0,
  792.     0,
  793.     0,
  794.     0,
  795.     0,
  796.     0,
  797.     0,
  798.     0,
  799.     0,
  800.     0,
  801.     0,
  802.     0,
  803.     0,
  804.     0,
  805.     0,
  806.     0,
  807.     0,
  808.     0,
  809.     0,
  810.     0,
  811.     0,
  812.     0,
  813.     0,
  814.     0,
  815.     0,
  816.     0,
  817.     0,
  818.     0,
  819.     0,
  820.     0,
  821.     0,
  822.     0,
  823.     0,
  824.     0,
  825.     0,
  826.     0,
  827.     0,
  828.     0,
  829.     0,
  830.     0,
  831.     0,
  832.     0,
  833.     0,
  834.     0,
  835.     0,
  836.     0,
  837.     0,
  838.     0,
  839.     0,
  840.     0,
  841.     0,
  842.     0,
  843.     0,
  844.     0,
  845.     0,
  846.     0,
  847.     0,
  848.     0,
  849.     0,
  850.     0,
  851.     0,
  852.     0,
  853.     0,
  854.     0,
  855.     0,
  856.     0,
  857.     0,
  858.     0,
  859.     0,
  860.     0,
  861.     0,
  862.     0,
  863.   };
  864.  
  865. char *insn_operand_constraint[][MAX_RECOG_OPERANDS] =
  866.   {
  867.     { "rK", "rK", },
  868.     { "r", },
  869.     { 0 },
  870.     { 0 },
  871.     { 0 },
  872.     { 0 },
  873.     { 0 },
  874.     { 0 },
  875.     { 0 },
  876.     { 0 },
  877.     { 0 },
  878.     { 0 },
  879.     { 0 },
  880.     { 0 },
  881.     { 0 },
  882.     { 0 },
  883.     { 0 },
  884.     { 0 },
  885.     { 0 },
  886.     { 0 },
  887.     { 0 },
  888.     { 0 },
  889.     { "=r,m", "rmi,rJ", },
  890.     { "=r", "r", "r", },
  891.     { "", "", },
  892.     { "=r,m", "rmi,r", },
  893.     { "=r", "r", "rI", },
  894.     { "+r", "rI", "ri", },
  895.     { "", "", "", "", "", },
  896.     { "", "", "", "", "", },
  897.     { "", "", "", "", },
  898.     { "", "", },
  899.     { "=r,m", "rmi,r", },
  900.     { "=r", "r", "rI", },
  901.     { "+r", "rI", "ri", },
  902.     { "=&r,f,&o", "mG,m,G", },
  903.     { "=r,&r,m,?f,?rm", "r,m,r,rfm,f", },
  904.     { "=r,&r,m,?f,?rm", "r,m,r,rfm,f", },
  905.     { "=rf,m", "rfm,rf", },
  906.     { "=r", "r", },
  907.     { "=r", "r", },
  908.     { "=r", "r", },
  909.     { "", "", },
  910.     { "=r", "r", },
  911.     { "=r", "r", },
  912.     { "", "", },
  913.     { "", "", },
  914.     { "", "", },
  915.     { "=r", "%r", "rI", },
  916.     { "=r", "%r", "g", },
  917.     { "=r", "r", "rI", },
  918.     { "=r", "%r", "rI", },
  919.     { "=r", "%r", "rI", },
  920.     { "=r", "%r", "rI", },
  921.     { "=r", "rI", },
  922.     { "=r", "r", },
  923.     { "=f", "f", "f", },
  924.     { "=f", "f", "f", },
  925.     { "=f", "f", "f", },
  926.     { "=f", "f", "f", },
  927.     { "=f", "f", "f", },
  928.     { "=f", "f", "f", },
  929.     { "=f", "f", "f", },
  930.     { "=f", "f", "f", },
  931.     { "=f", "f", },
  932.     { "=f", "f", },
  933.     { "=f", "f", },
  934.     { "=f", "f", },
  935.     { "=r", "r", "I", },
  936.     { "=r", "r", "I", },
  937.     { "=r", "r", "I", },
  938.     { "", "", "", },
  939.     { "", "", "", },
  940.     { "", "", "", },
  941.     { "", "", "", },
  942.     { 0 },
  943.     { "r", },
  944.     { "m", "g", },
  945.     { "g", "m", "g", },
  946.     { "i", "g", },
  947.     { "g", "i", "g", },
  948.   };
  949.  
  950. enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =
  951.   {
  952.     { SImode, SImode, },
  953.     { SImode, },
  954.     { VOIDmode },
  955.     { VOIDmode },
  956.     { VOIDmode },
  957.     { VOIDmode },
  958.     { VOIDmode },
  959.     { VOIDmode },
  960.     { VOIDmode },
  961.     { VOIDmode },
  962.     { VOIDmode },
  963.     { VOIDmode },
  964.     { VOIDmode },
  965.     { VOIDmode },
  966.     { VOIDmode },
  967.     { VOIDmode },
  968.     { VOIDmode },
  969.     { VOIDmode },
  970.     { VOIDmode },
  971.     { VOIDmode },
  972.     { VOIDmode },
  973.     { VOIDmode },
  974.     { SImode, SImode, },
  975.     { SImode, SImode, SImode, },
  976.     { QImode, QImode, },
  977.     { QImode, QImode, },
  978.     { SImode, SImode, SImode, },
  979.     { SImode, SImode, SImode, },
  980.     { HImode, SImode, SImode, SImode, QImode, },
  981.     { SImode, HImode, SImode, SImode, QImode, },
  982.     { SImode, VOIDmode, SImode, SImode, },
  983.     { HImode, HImode, },
  984.     { HImode, HImode, },
  985.     { SImode, HImode, SImode, },
  986.     { HImode, SImode, SImode, },
  987.     { DFmode, DFmode, },
  988.     { DFmode, DFmode, },
  989.     { DImode, DImode, },
  990.     { SFmode, SFmode, },
  991.     { QImode, SImode, },
  992.     { QImode, HImode, },
  993.     { HImode, SImode, },
  994.     { SImode, HImode, },
  995.     { HImode, QImode, },
  996.     { SImode, QImode, },
  997.     { SImode, HImode, },
  998.     { HImode, QImode, },
  999.     { SImode, QImode, },
  1000.     { SImode, SImode, SImode, },
  1001.     { SImode, SImode, SImode, },
  1002.     { SImode, SImode, SImode, },
  1003.     { SImode, SImode, SImode, },
  1004.     { SImode, SImode, SImode, },
  1005.     { SImode, SImode, SImode, },
  1006.     { SImode, SImode, },
  1007.     { SImode, SImode, },
  1008.     { DFmode, DFmode, DFmode, },
  1009.     { SFmode, SFmode, SFmode, },
  1010.     { DFmode, DFmode, DFmode, },
  1011.     { SFmode, SFmode, SFmode, },
  1012.     { DFmode, DFmode, DFmode, },
  1013.     { SFmode, SFmode, SFmode, },
  1014.     { DFmode, DFmode, DFmode, },
  1015.     { SFmode, SFmode, SFmode, },
  1016.     { DFmode, DFmode, },
  1017.     { SFmode, SFmode, },
  1018.     { DFmode, DFmode, },
  1019.     { SFmode, SFmode, },
  1020.     { SImode, SImode, SImode, },
  1021.     { SImode, SImode, SImode, },
  1022.     { SImode, SImode, SImode, },
  1023.     { SImode, SImode, SImode, },
  1024.     { SImode, SImode, SImode, },
  1025.     { SImode, SImode, SImode, },
  1026.     { SImode, SImode, SImode, },
  1027.     { VOIDmode },
  1028.     { SImode, },
  1029.     { SImode, SImode, },
  1030.     { VOIDmode, SImode, SImode, },
  1031.     { SImode, SImode, },
  1032.     { VOIDmode, SImode, SImode, },
  1033.   };
  1034.  
  1035. char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =
  1036.   {
  1037.     { 0, 0, },
  1038.     { 0, },
  1039.     { 0 },
  1040.     { 0 },
  1041.     { 0 },
  1042.     { 0 },
  1043.     { 0 },
  1044.     { 0 },
  1045.     { 0 },
  1046.     { 0 },
  1047.     { 0 },
  1048.     { 0 },
  1049.     { 0 },
  1050.     { 0 },
  1051.     { 0 },
  1052.     { 0 },
  1053.     { 0 },
  1054.     { 0 },
  1055.     { 0 },
  1056.     { 0 },
  1057.     { 0 },
  1058.     { 0 },
  1059.     { 0, 0, },
  1060.     { 0, 0, 0, },
  1061.     { 0, 0, },
  1062.     { 0, 0, },
  1063.     { 0, 0, 0, },
  1064.     { 0, 0, 0, },
  1065.     { 0, 0, 0, 0, 0, },
  1066.     { 0, 0, 0, 0, 0, },
  1067.     { 0, 0, 0, 0, },
  1068.     { 0, 0, },
  1069.     { 0, 0, },
  1070.     { 0, 0, 0, },
  1071.     { 0, 0, 0, },
  1072.     { 0, 0, },
  1073.     { 0, 0, },
  1074.     { 0, 0, },
  1075.     { 0, 0, },
  1076.     { 0, 0, },
  1077.     { 0, 0, },
  1078.     { 0, 0, },
  1079.     { 0, 0, },
  1080.     { 0, 0, },
  1081.     { 0, 0, },
  1082.     { 0, 0, },
  1083.     { 0, 0, },
  1084.     { 0, 0, },
  1085.     { 0, 0, 0, },
  1086.     { 0, 0, 0, },
  1087.     { 0, 0, 0, },
  1088.     { 0, 0, 0, },
  1089.     { 0, 0, 0, },
  1090.     { 0, 0, 0, },
  1091.     { 0, 0, },
  1092.     { 0, 0, },
  1093.     { 0, 0, 0, },
  1094.     { 0, 0, 0, },
  1095.     { 0, 0, 0, },
  1096.     { 0, 0, 0, },
  1097.     { 0, 0, 0, },
  1098.     { 0, 0, 0, },
  1099.     { 0, 0, 0, },
  1100.     { 0, 0, 0, },
  1101.     { 0, 0, },
  1102.     { 0, 0, },
  1103.     { 0, 0, },
  1104.     { 0, 0, },
  1105.     { 0, 0, 0, },
  1106.     { 0, 0, 0, },
  1107.     { 0, 0, 0, },
  1108.     { 0, 0, 0, },
  1109.     { 0, 0, 0, },
  1110.     { 0, 0, 0, },
  1111.     { 0, 0, 0, },
  1112.     { 0 },
  1113.     { 0, },
  1114.     { 0, 0, },
  1115.     { 0, 0, 0, },
  1116.     { 0, 0, },
  1117.     { 0, 0, 0, },
  1118.   };
  1119.  
  1120. int (*insn_operand_predicate[][MAX_RECOG_OPERANDS])() =
  1121.   {
  1122.     { nonmemory_operand, nonmemory_operand, },
  1123.     { register_operand, },
  1124.     { 0 },
  1125.     { 0 },
  1126.     { 0 },
  1127.     { 0 },
  1128.     { 0 },
  1129.     { 0 },
  1130.     { 0 },
  1131.     { 0 },
  1132.     { 0 },
  1133.     { 0 },
  1134.     { 0 },
  1135.     { 0 },
  1136.     { 0 },
  1137.     { 0 },
  1138.     { 0 },
  1139.     { 0 },
  1140.     { 0 },
  1141.     { 0 },
  1142.     { 0 },
  1143.     { 0 },
  1144.     { general_operand, general_operand, },
  1145.     { register_operand, register_operand, register_operand, },
  1146.     { general_operand, general_operand, },
  1147.     { general_operand, general_operand, },
  1148.     { register_operand, register_operand, nonmemory_operand, },
  1149.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1150.     { register_operand, register_operand, register_operand, register_operand, register_operand, },
  1151.     { register_operand, register_operand, register_operand, register_operand, register_operand, },
  1152.     { register_operand, 0, register_operand, register_operand, },
  1153.     { general_operand, general_operand, },
  1154.     { general_operand, general_operand, },
  1155.     { register_operand, register_operand, nonmemory_operand, },
  1156.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1157.     { general_operand, 0, },
  1158.     { general_operand, general_operand, },
  1159.     { general_operand, general_operand, },
  1160.     { general_operand, general_operand, },
  1161.     { register_operand, register_operand, },
  1162.     { register_operand, register_operand, },
  1163.     { register_operand, register_operand, },
  1164.     { register_operand, register_operand, },
  1165.     { register_operand, register_operand, },
  1166.     { register_operand, register_operand, },
  1167.     { register_operand, register_operand, },
  1168.     { register_operand, register_operand, },
  1169.     { register_operand, register_operand, },
  1170.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1171.     { register_operand, nonmemory_operand, big_immediate_operand, },
  1172.     { register_operand, register_operand, nonmemory_operand, },
  1173.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1174.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1175.     { register_operand, nonmemory_operand, nonmemory_operand, },
  1176.     { register_operand, nonmemory_operand, },
  1177.     { register_operand, register_operand, },
  1178.     { register_operand, register_operand, register_operand, },
  1179.     { register_operand, register_operand, register_operand, },
  1180.     { register_operand, register_operand, register_operand, },
  1181.     { register_operand, register_operand, register_operand, },
  1182.     { register_operand, register_operand, register_operand, },
  1183.     { register_operand, register_operand, register_operand, },
  1184.     { register_operand, register_operand, register_operand, },
  1185.     { register_operand, register_operand, register_operand, },
  1186.     { register_operand, nonmemory_operand, },
  1187.     { register_operand, nonmemory_operand, },
  1188.     { register_operand, nonmemory_operand, },
  1189.     { register_operand, nonmemory_operand, },
  1190.     { register_operand, register_operand, immediate_operand, },
  1191.     { register_operand, register_operand, immediate_operand, },
  1192.     { register_operand, register_operand, immediate_operand, },
  1193.     { register_operand, register_operand, nonmemory_operand, },
  1194.     { register_operand, register_operand, nonmemory_operand, },
  1195.     { register_operand, register_operand, nonmemory_operand, },
  1196.     { register_operand, register_operand, nonmemory_operand, },
  1197.     { 0 },
  1198.     { register_operand, },
  1199.     { memory_operand, general_operand, },
  1200.     { 0, memory_operand, general_operand, },
  1201.     { 0, general_operand, },
  1202.     { 0, 0, general_operand, },
  1203.   };
  1204.